// 视频片花跳过器 - 内容脚本
(() => {
  console.log('视频片花跳过器: 内容脚本已加载');
  
  // 状态变量
  let videoElement = null;          // 当前视频元素
  let currentMode = 'manual';       // 当前工作模式: manual, auto, prompt
  let customRules = [];             // 自定义跳过规则
  let checkInterval = null;         // 视频检查定时器
  let processingFrame = false;      // 是否正在处理帧
  let lastProcessedTime = 0;        // 上次处理的时间点
  let skippedSegments = [];         // 已跳过的片段
  let promptDialogActive = false;   // 提示对话框是否激活
  let audioContext = null;          // 音频上下文（用于分析）
  let audioAnalyzer = null;         // 音频分析器
  let audioDataArray = null;        // 音频数据数组
  let faceDetector = null;          // 人脸检测器
  let findingVideo = false;         // 是否正在寻找视频
  let videoFindAttempts = 0;        // 尝试寻找视频的次数
  let audioInitialized = false;     // 音频是否已初始化
  let videoObserver = null;         // 视频元素观察器
  let documentLoaded = false;       // 文档是否已加载完成
  let activeSkipRules = [];         // 活动的跳过规则（包括自定义和手动设置的）
  let currentSpeed = 1;             // 当前播放速度
  let speedControlActive = false;   // 速度控制是否激活
  // 静止画面检测相关变量
  let previousFrameData = null;     // 上一帧的数据
  let similarFramesCount = 0;       // 连续相似帧计数
  let frameCheckInterval = null;    // 帧检测定时器
  let lastFrameCheckTime = 0;       // 上次帧检测时间
  let staticSceneStartTime = null;  // 静止画面开始时间
  // 倍速控制相关
  let speedControlDiv = null;       // 倍速控制界面
  let originalSpeed = 1;            // 原始播放速度

  // 初始化
  function init() {
    console.log('视频片花跳过器: 开始初始化');
    
    // 等待文档加载完成
    if (document.readyState === 'loading') {
      document.addEventListener('DOMContentLoaded', onDocumentLoaded);
    } else {
      onDocumentLoaded();
    }
    
    // 监听来自弹出窗口或后台脚本的消息
    chrome.runtime.onMessage.addListener(handleMessage);
    
    // 通知后台脚本内容脚本已加载
    try {
      chrome.runtime.sendMessage({ action: 'contentScriptLoaded' });
    } catch (e) {
      console.error('通知后台脚本失败:', e);
    }
    
    console.log('视频片花跳过器: 初始化完成');
  }
  
  // 文档加载完成时的处理
  function onDocumentLoaded() {
    documentLoaded = true;
    
    // 从存储中加载设置
    loadSettings();
    
    // 设置视频元素观察器
    setupVideoObserver();
    
    // 延迟查找视频，有些网站视频加载可能较慢
    setTimeout(findVideoElement, 1000);
  }
  
  // 设置视频元素观察器
  function setupVideoObserver() {
    // 如果已有观察器，先断开连接
    if (videoObserver) {
      videoObserver.disconnect();
    }
    
    // 创建一个观察器，监控DOM变化，检测新添加的视频元素
    videoObserver = new MutationObserver((mutations) => {
      let shouldCheckVideo = false;
      
      for (const mutation of mutations) {
        if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
          for (const node of mutation.addedNodes) {
            // 如果添加了视频元素或者包含视频元素的元素
            if (node.tagName === 'VIDEO' || 
                (node.nodeType === 1 && node.querySelector('video'))) {
              shouldCheckVideo = true;
              break;
            }
          }
        }
        
        if (shouldCheckVideo) break;
      }
      
      if (shouldCheckVideo && !videoElement) {
        console.log('视频片花跳过器: 检测到DOM变化，可能有新的视频元素');
        findVideoElement();
      }
    });
    
    // 开始观察
    videoObserver.observe(document.documentElement, {
      childList: true,
      subtree: true,
    });
    
    console.log('视频片花跳过器: 视频元素观察器已设置');
  }
  
  // 通知视频已找到
  function notifyVideoFound() {
    try {
      // 通知后台脚本视频已找到
      chrome.runtime.sendMessage({ 
        action: 'videoFound',
        videoInfo: {
          duration: videoElement.duration,
          currentTime: videoElement.currentTime,
          paused: videoElement.paused,
          src: videoElement.src
        }
      });
      
      console.log('视频片花跳过器: 已通知后台脚本视频已找到');
    } catch (error) {
      console.error('通知视频已找到失败:', error);
    }
  }
  
  // 查找页面中的视频元素 - 改进版
  function findVideoElement() {
    if (findingVideo) return;
    findingVideo = true;
    videoFindAttempts++;
    
    console.log('视频片花跳过器: 开始查找视频元素, 尝试次数:', videoFindAttempts);
    
    // 增加最大尝试次数
    if (videoFindAttempts > 20) {
      console.log('视频片花跳过器: 达到最大尝试次数，停止主动查找，等待视频元素出现');
      findingVideo = false;
      return;
    }
    
    try {
      // 创建一个数组来存储所有找到的视频元素
      let allVideos = [];
      
      // 1. 首先尝试查找哔哩哔哩特定的视频元素
      try {
        // 哔哩哔哩主播放器
        const biliMainPlayer = document.querySelector('.bilibili-player-video video');
        if (biliMainPlayer) {
          allVideos.push(biliMainPlayer);
        }
        
        // 哔哩哔哩弹幕播放器
        const biliDanmakuPlayer = document.querySelector('.bilibili-player-video-danmaku video');
        if (biliDanmakuPlayer) {
          allVideos.push(biliDanmakuPlayer);
        }
        
        // 哔哩哔哩通用播放器
        const biliGenericPlayer = document.querySelector('.bilibili-player video');
        if (biliGenericPlayer) {
          allVideos.push(biliGenericPlayer);
        }
      } catch (e) {
        console.log('查找哔哩哔哩视频元素时出错:', e);
      }
      
      // 2. 检查所有视频元素
      try {
        const mainVideos = document.querySelectorAll('video');
        if (mainVideos && mainVideos.length > 0) {
          allVideos = allVideos.concat(Array.from(mainVideos));
        }
      } catch (e) {
        console.log('查找主页面视频元素时出错:', e);
      }
      
      // 3. 检查 iframe 中的视频
      try {
        const iframes = document.querySelectorAll('iframe');
        for (const iframe of iframes) {
          try {
            // 检查iframe是否可访问且已加载
            if (iframe.contentDocument && iframe.contentDocument.readyState === 'complete') {
              const iframeVideos = iframe.contentDocument.querySelectorAll('video');
              if (iframeVideos && iframeVideos.length > 0) {
                allVideos = allVideos.concat(Array.from(iframeVideos));
              }
            }
          } catch (e) {
            // 忽略跨域iframe的错误
            console.log('无法访问iframe内容:', e);
          }
        }
      } catch (e) {
        console.log('查找iframe视频元素时出错:', e);
      }
      
      // 4. 检查特定平台的视频容器
      try {
        const platformSpecificSelectors = [
          '.video-player',           // 通用视频播放器
          '.bilibili-player',        // 哔哩哔哩
          '.chaoxing-player',        // 超星学习通
          '.mooc-player',           // 慕课
          '.course-video',          // 课程视频
          '[class*="video"]',       // 包含video的类名
          '[id*="video"]'           // 包含video的ID
        ];
        
        for (const selector of platformSpecificSelectors) {
          const containers = document.querySelectorAll(selector);
          if (containers && containers.length > 0) {
            for (const container of containers) {
              const containerVideos = container.querySelectorAll('video');
              if (containerVideos && containerVideos.length > 0) {
                allVideos = allVideos.concat(Array.from(containerVideos));
              }
            }
          }
        }
      } catch (e) {
        console.log('查找平台特定视频元素时出错:', e);
      }
      
      // 5. 检查shadow DOM中的视频
      try {
        const shadowRoots = document.querySelectorAll('*');
        for (const element of shadowRoots) {
          if (element.shadowRoot) {
            const shadowVideos = element.shadowRoot.querySelectorAll('video');
            if (shadowVideos && shadowVideos.length > 0) {
              allVideos = allVideos.concat(Array.from(shadowVideos));
            }
          }
        }
      } catch (e) {
        console.log('检查Shadow DOM时出错:', e);
      }
      
      // 移除重复的视频元素
      allVideos = Array.from(new Set(allVideos));
      
      console.log('视频片花跳过器: 找到', allVideos.length, '个视频元素');
      
      if (allVideos.length > 0) {
        // 改进视频选择逻辑
        for (const video of allVideos) {
          try {
            if (isVideoPlayable(video) && isElementVisibleAndPlayable(video)) {
              const rect = video.getBoundingClientRect();
              // 降低尺寸要求，适应更多场景
              if (rect.width > 50 && rect.height > 50) {
                videoElement = video;
                console.log('视频片花跳过器: 选中视频元素', video);
                break;
              }
            }
          } catch (e) {
            console.log('检查视频元素时出错:', e);
            continue;
          }
        }
      }
      
      // 如果找到视频，初始化处理逻辑
      if (videoElement) {
        setupVideoHandling();
        notifyVideoFound();
      } else {
        // 没找到视频，过一段时间再尝试
        setTimeout(findVideoElement, 2000);
      }
    } catch (error) {
      console.error('查找视频元素出错:', error);
    } finally {
      findingVideo = false;
    }
  }
  
  // 检查视频是否可播放
  function isVideoPlayable(video) {
    try {
      // 检查视频是否已加载元数据
      const hasMetadata = video.readyState >= 1;
      // 检查视频是否有源
      const hasSource = video.src || video.querySelector('source');
      // 检查视频是否可播放
      const canPlay = video.duration > 0;
      
      return hasMetadata || hasSource || canPlay;
    } catch (error) {
      console.error('检查视频可播放状态出错:', error);
      return false;
    }
  }
  
  // 检查元素是否可见且可能可播放
  function isElementVisibleAndPlayable(element) {
    try {
      const style = window.getComputedStyle(element);
      const isVisible = style.display !== 'none' && 
                        style.visibility !== 'hidden' && 
                        style.opacity !== '0';
                        
      // 检查元素是否在视口中
      const rect = element.getBoundingClientRect();
      const isInViewport = rect.top < window.innerHeight && 
                          rect.bottom > 0 && 
                          rect.left < window.innerWidth && 
                          rect.right > 0;
      
      return isVisible && isInViewport;
    } catch (error) {
      console.error('检查元素可见性出错:', error);
      return false;
    }
  }
  
  // 设置视频处理逻辑
  function setupVideoHandling() {
    console.log('视频片花跳过器: 设置视频处理逻辑');
    
    try {
      // 初始化音频分析 - 延迟到用户交互
      setupAudioAnalysis();
      
      // 初始化人脸检测（如果浏览器支持）
      setupFaceDetection();
      
      // 为视频添加事件监听器
      videoElement.addEventListener('timeupdate', onTimeUpdate);
      videoElement.addEventListener('play', onVideoPlay);
      videoElement.addEventListener('pause', onVideoPause);
      
      // 开始定期检查视频内容
      startVideoContentCheck();
      
      // 开始静止画面检测
      startStaticSceneDetection();
      
      console.log('视频片花跳过器: 视频处理逻辑已设置');
    } catch (error) {
      console.error('设置视频处理逻辑出错:', error);
    }
  }
  
  // 视频播放事件处理
  function onVideoPlay() {
    console.log('视频片花跳过器: 视频开始播放');
    
    // 如果音频尚未初始化，尝试初始化
    if (!audioInitialized) {
      initAudioAnalysisOnInteraction();
    }
    
    // 如果是手动模式，添加倍速控制启动按钮
    if (currentMode === 'manual') {
      createSpeedControlButton();
    }
  }
  
  // 视频暂停事件处理
  function onVideoPause() {
    console.log('视频片花跳过器: 视频已暂停');
    // 重置静止画面检测
    resetStaticSceneDetection();
  }
  
  // 从存储中加载设置
  function loadSettings() {
    try {
      chrome.storage.local.get(['mode', 'customRules'], function(result) {
        if (chrome.runtime.lastError) {
          console.error('加载设置失败:', chrome.runtime.lastError);
          return;
        }
        
        if (result.mode) {
          currentMode = result.mode;
          
          // 根据模式判断是否显示倍速控制按钮
          if (currentMode === 'manual' && videoElement && !videoElement.paused) {
            createSpeedControlButton();
          } else if (currentMode !== 'manual') {
            removeSpeedControlButton();
            removeSpeedControlUI();
          }
        }
        
        if (result.customRules) {
          customRules = result.customRules;
          // 转换为活动规则
          updateActiveRules();
        }
        
        console.log('视频片花跳过器: 已加载设置, 模式:', currentMode, '规则数:', customRules.length);
      });
    } catch (error) {
      console.error('加载设置出错:', error);
    }
  }
  
  // 更新活动规则
  function updateActiveRules() {
    activeSkipRules = [];
    
    // 添加自定义规则
    if (customRules && customRules.length > 0) {
      customRules.forEach(rule => {
        activeSkipRules.push({
          from: rule.fromSeconds || (rule.from.minutes * 60 + rule.from.seconds),
          to: rule.toSeconds || (rule.to.minutes * 60 + rule.to.seconds),
          type: '自定义规则'
        });
      });
    }
    
    console.log('视频片花跳过器: 活动规则已更新', activeSkipRules);
  }
  
  // 添加手动规则
  function addManualRule(fromSeconds, toSeconds) {
    // 添加到活动规则中
    activeSkipRules.push({
      from: fromSeconds,
      to: toSeconds,
      type: '手动跳过规则'
    });
    
    console.log('视频片花跳过器: 添加手动规则', fromSeconds, toSeconds);
  }
  
  // 初始化音频分析
  function setupAudioAnalysis() {
    // 延迟初始化音频分析，等待用户交互
    videoElement.addEventListener('play', initAudioAnalysisOnInteraction, { once: true });
    
    // 添加点击事件监听器，许多网站需要用户交互才能使用AudioContext
    document.addEventListener('click', function audioClickHandler() {
      if (!audioInitialized && videoElement) {
        initAudioAnalysisOnInteraction();
      }
      
      // 仅触发一次
      if (audioInitialized) {
        document.removeEventListener('click', audioClickHandler);
      }
    });
  }
  
  // 在用户交互后初始化音频分析
  function initAudioAnalysisOnInteraction() {
    if (audioInitialized) return;
    
    try {
      // 创建音频上下文
      audioContext = new (window.AudioContext || window.webkitAudioContext)();
      
      // 等待音频上下文就绪
      if (audioContext.state === 'suspended') {
        console.log('视频片花跳过器: 音频上下文已挂起，等待用户交互恢复');
        // 我们这里不需要处理 resume，浏览器会在用户交互时自动恢复
      }
      
      // 创建音频源（来自视频元素）
      const source = audioContext.createMediaElementSource(videoElement);
      
      // 创建分析器
      audioAnalyzer = audioContext.createAnalyser();
      audioAnalyzer.fftSize = 256;
      
      // 连接节点: 源 -> 分析器 -> 目标（扬声器）
      source.connect(audioAnalyzer);
      source.connect(audioContext.destination);
      
      // 创建数据数组
      audioDataArray = new Uint8Array(audioAnalyzer.frequencyBinCount);
      
      audioInitialized = true;
      console.log('视频片花跳过器: 音频分析初始化成功');
    } catch (error) {
      console.error('视频片花跳过器: 音频分析初始化失败', error);
      // 失败后标记为null，以便使用备用方法
      audioContext = null;
      audioAnalyzer = null;
      
      // 即使失败，也标记为已尝试过，避免重复尝试
      audioInitialized = true;
    }
  }
  
  // 初始化人脸检测
  function setupFaceDetection() {
    try {
      // 检查浏览器是否支持人脸检测API
      if ('FaceDetector' in window) {
        try {
          faceDetector = new FaceDetector();
          console.log('视频片花跳过器: 人脸检测初始化成功');
        } catch (error) {
          console.error('视频片花跳过器: 人脸检测初始化失败', error);
          faceDetector = null;
        }
      } else {
        console.log('视频片花跳过器: 浏览器不支持人脸检测API，将使用替代方法');
      }
    } catch (error) {
      console.error('设置人脸检测出错:', error);
      faceDetector = null;
    }
  }
  
  // 处理视频时间更新事件
  function onTimeUpdate() {
    if (!videoElement) return;
    
    try {
      const currentTime = videoElement.currentTime;
      
      // 检查所有规则（包括自定义规则和手动添加的规则）
      checkAllRules(currentTime);
      
      // 根据当前模式处理视频
      if (currentMode === 'auto' || currentMode === 'prompt') {
        // 每秒只处理一次，避免过于频繁
        if (currentTime - lastProcessedTime >= 1 && !processingFrame) {
          processCurrentFrame(currentTime);
        }
      }
    } catch (error) {
      console.error('视频时间更新处理出错:', error);
    }
  }
  
  // 检查所有规则（包括自定义规则和手动添加的规则）
  function checkAllRules(currentTime) {
    if (!activeSkipRules || activeSkipRules.length === 0) return;
    
    try {
      for (const rule of activeSkipRules) {
        const fromSeconds = rule.from;
        const toSeconds = rule.to;
        
        // 如果当前时间在规则范围内，直接跳过
        if (currentTime >= fromSeconds && currentTime < toSeconds) {
          console.log(`视频片花跳过器: 根据规则跳过 ${formatTime(fromSeconds)} 到 ${formatTime(toSeconds)} (${rule.type})`);
          
          // 记录被跳过的片段
          const skippedSegment = {
            from: { 
              minutes: Math.floor(fromSeconds / 60), 
              seconds: Math.floor(fromSeconds % 60) 
            },
            to: { 
              minutes: Math.floor(toSeconds / 60), 
              seconds: Math.floor(toSeconds % 60) 
            },
            type: rule.type
          };
          addSkippedSegment(skippedSegment);
          
          // 直接跳到规则结束时间
          videoElement.currentTime = toSeconds;
          return;
        }
      }
    } catch (error) {
      console.error('检查规则出错:', error);
    }
  }
  
  // 开始视频内容检查
  function startVideoContentCheck() {
    try {
      if (checkInterval) clearInterval(checkInterval);
      
      // 每5秒检查一次视频内容，在auto或prompt模式下
      checkInterval = setInterval(() => {
        if (!videoElement) return;
        
        if ((currentMode === 'auto' || currentMode === 'prompt') && videoElement && videoElement.paused === false) {
          processCurrentFrame(videoElement.currentTime);
        }
      }, 5000);
    } catch (error) {
      console.error('启动视频内容检查出错:', error);
    }
  }
  
  // 开始静止画面检测
  function startStaticSceneDetection() {
    // 清除可能存在的旧定时器
    if (frameCheckInterval) {
      clearInterval(frameCheckInterval);
    }
    
    // 重置检测状态
    resetStaticSceneDetection();
    
    // 每500毫秒进行一次帧检测
    frameCheckInterval = setInterval(() => {
      if (!videoElement || videoElement.paused) return;
      
      // 如果视频在播放，且处于自动或提示模式
      if ((currentMode === 'auto' || currentMode === 'prompt') && !processingFrame) {
        // 限制检测频率，每秒最多检测2次
        const now = Date.now();
        if (now - lastFrameCheckTime >= 500) {
          lastFrameCheckTime = now;
          checkFrameSimilarity();
        }
      }
    }, 500);
    
    console.log('视频片花跳过器: 静止画面检测已启动');
  }
  
  // 重置静止画面检测状态
  function resetStaticSceneDetection() {
    previousFrameData = null;
    similarFramesCount = 0;
    staticSceneStartTime = null;
  }
  
  // 检查帧相似度
  function checkFrameSimilarity() {
    if (!videoElement || processingFrame) return;
    
    try {
      // 创建Canvas获取当前帧
      const canvas = document.createElement('canvas');
      const context = canvas.getContext('2d');
      const width = 100;  // 降低分辨率以提高性能
      const height = 56;  // 保持宽高比 16:9
      
      canvas.width = width;
      canvas.height = height;
      
      // 将当前视频帧绘制到Canvas
      context.drawImage(videoElement, 0, 0, width, height);
      
      // 获取帧数据
      const imageData = context.getImageData(0, 0, width, height);
      const currentFrameData = imageData.data;
      
      // 如果有上一帧数据，计算相似度
      if (previousFrameData) {
        const similarity = calculateImageSimilarity(previousFrameData, currentFrameData);
        
        // 相似度阈值（95%以上认为是静止画面）
        if (similarity > 0.95) {
          similarFramesCount++;
          
          // 记录静止画面开始时间
          if (similarFramesCount === 1) {
            staticSceneStartTime = videoElement.currentTime;
          }
          
          // 如果连续10次（大约5秒）检测到高相似度，判定为静止画面
          if (similarFramesCount >= 10) {
            const staticSceneDuration = videoElement.currentTime - staticSceneStartTime;
            
            // 如果静止画面持续时间超过3秒，进行跳过处理
            if (staticSceneDuration >= 3 && currentMode === 'auto') {
              handleStaticScene(staticSceneStartTime, staticSceneDuration);
            }
          }
        } else {
          // 重置计数
          resetStaticSceneDetection();
        }
      }
      
      // 保存当前帧数据用于下次比较
      previousFrameData = currentFrameData;
      
    } catch (error) {
      console.error('检查帧相似度失败:', error);
      resetStaticSceneDetection();
    }
  }
  
  // 计算两帧之间的相似度
  function calculateImageSimilarity(data1, data2) {
    const length = data1.length;
    let matchingPixels = 0;
    let threshold = 10;  // 颜色差异阈值
    
    // 每隔4个像素采样，减少计算量
    for (let i = 0; i < length; i += 16) {
      // 计算RGB三个通道的差异
      const rDiff = Math.abs(data1[i] - data2[i]);
      const gDiff = Math.abs(data1[i + 1] - data2[i + 1]);
      const bDiff = Math.abs(data1[i + 2] - data2[i + 2]);
      
      // 如果RGB差异都小于阈值，认为像素相似
      if (rDiff < threshold && gDiff < threshold && bDiff < threshold) {
        matchingPixels++;
      }
    }
    
    // 计算相似度（匹配像素比例）
    return matchingPixels / (length / 16);
  }
  
  // 处理静止画面
  function handleStaticScene(startTime, duration) {
    // 确定跳过到的时间点（静止画面开始时间 + 持续时间 + 额外2秒）
    const skipToTime = startTime + duration + 2;
    
    // 确保不会跳过视频结尾
    if (skipToTime >= videoElement.duration) {
      resetStaticSceneDetection();
      return;
    }
    
    console.log(`视频片花跳过器: 检测到静止画面，从 ${formatTime(startTime)} 跳过 ${duration.toFixed(1)} 秒到 ${formatTime(skipToTime)}`);
    
    // 记录跳过的片段
    const skippedSegment = {
      from: { 
        minutes: Math.floor(startTime / 60), 
        seconds: Math.floor(startTime % 60) 
      },
      to: { 
        minutes: Math.floor(skipToTime / 60), 
        seconds: Math.floor(skipToTime % 60) 
      },
      type: '静止画面'
    };
    addSkippedSegment(skippedSegment);
    
    // 跳到目标时间
    videoElement.currentTime = skipToTime;
    
    // 重置检测状态
    resetStaticSceneDetection();
  }
  
  // 处理当前视频帧
  function processCurrentFrame(currentTime) {
    if (!videoElement || processingFrame || promptDialogActive) return;
    
    processingFrame = true;
    lastProcessedTime = currentTime;
    
    try {
      // 创建一个Canvas用于捕获视频帧
      const canvas = document.createElement('canvas');
      const context = canvas.getContext('2d');
      canvas.width = videoElement.videoWidth || 640;
      canvas.height = videoElement.videoHeight || 360;
      
      // 将当前视频帧绘制到Canvas
      context.drawImage(videoElement, 0, 0, canvas.width, canvas.height);
      
      // 检测是否有音频
      const hasAudio = detectAudio();
      
      // 分析帧
      analyzeFrame(canvas, hasAudio, currentTime)
        .then(result => {
          handleAnalysisResult(result, currentTime);
          processingFrame = false;
        })
        .catch(error => {
          console.error('视频片花跳过器: 分析帧出错', error);
          processingFrame = false;
        });
    } catch (error) {
      console.error('处理视频帧失败:', error);
      processingFrame = false;
    }
  }
  
  // 分析视频帧 (使用JavaScript实现而非Python后端)
  async function analyzeFrame(canvas, hasAudio, currentTime) {
    let hasFaces = false;
    let hasText = false;
    let hasSignificantAudio = false;
    let audioFeatures = null;
    let sceneComplexity = 0;
    let isStaticScene = false;
    
    try {
      // 1. 音频分析
      if (hasAudio) {
        audioFeatures = analyzeAudioFeatures(audioDataArray);
        hasSignificantAudio = audioFeatures.hasSignificantAudio;
      }
      
      // 2. 人脸检测
      if (faceDetector) {
        try {
          const faces = await faceDetector.detect(canvas);
          hasFaces = faces.length > 0;
        } catch (error) {
          console.error('视频片花跳过器: 人脸检测出错', error);
          // 退回到改进的肤色检测
          hasFaces = detectSkin(canvas);
        }
      } else {
        // 退回到改进的肤色检测
        hasFaces = detectSkin(canvas);
      }
      
      // 3. 文字检测
      hasText = detectText(canvas);
      
      // 4. 场景复杂度分析
      sceneComplexity = analyzeSceneComplexity(canvas);
      
      // 5. 静止画面检测
      isStaticScene = checkStaticScene(canvas);
      
      // 6. 判断逻辑
      let isPossibleIntro = false;
      let confidence = 0.5;
      let reason = "";
      
      // 综合评分系统
      let score = 0;
      
      // 音频特征评分 - 降低音频权重
      if (!hasSignificantAudio) {
        score += 0.2;  // 降低权重
        reason += "没有检测到显著音频; ";
      } else if (audioFeatures && audioFeatures.isBackgroundMusic) {
        score += 0.1;  // 降低权重
        reason += "检测到背景音乐; ";
      } else {
        // 如果有显著音频且不是背景音乐，降低跳过可能性
        score -= 0.3;  // 降低权重
        reason += "检测到重要音频内容; ";
      }
      
      // 人脸特征评分 - 降低人脸权重
      if (!hasFaces) {
        score += 0.1;  // 降低权重
        reason += "没有检测到人脸; ";
      } else {
        score -= 0.2;  // 降低权重
        reason += "检测到人脸; ";
      }
      
      // 文字特征评分 - 增加文字权重
      if (!hasText) {
        score += 0.2;  // 增加权重
        reason += "没有检测到文字; ";
      } else {
        score -= 0.3;  // 增加权重
        reason += "检测到文字; ";
      }
      
      // 场景复杂度评分 - 增加复杂度权重
      if (sceneComplexity < 0.3) {
        score += 0.2;  // 增加权重
        reason += "场景复杂度低; ";
      } else {
        score -= 0.2;  // 增加权重
        reason += "场景复杂度高; ";
      }
      
      // 静止画面评分 - 增加静止画面权重
      if (isStaticScene) {
        score += 0.3;  // 增加权重
        reason += "检测到静止画面; ";
      }
      
      // 时间位置评分 - 降低时间位置权重
      if (currentTime < 30) { // 视频开始30秒内
        score += 0.05;  // 降低权重
        reason += "位于视频开始部分; ";
      }
      
      // 最终判断 - 提高阈值
      isPossibleIntro = score >= 0.7;  // 提高阈值
      confidence = score;
      
      // 建议跳过的时长 - 减少跳过时长
      let suggestedSkipDuration = 0;
      if (isPossibleIntro) {
        if (currentTime < 30) {
          // 视频开始部分，根据场景特征决定跳过时长
          if (isStaticScene) {
            suggestedSkipDuration = 10; // 减少静止画面跳过时长
          } else if (!hasSignificantAudio && !hasFaces && !hasText) {
            suggestedSkipDuration = 15; // 减少无内容跳过时长
          } else {
            suggestedSkipDuration = 5; // 减少其他情况跳过时长
          }
        } else if (isStaticScene) {
          // 非开始部分的静止画面
          if (!hasSignificantAudio && !hasFaces && !hasText) {
            suggestedSkipDuration = 5; // 减少完全静止跳过时长
          } else {
            suggestedSkipDuration = 3; // 减少部分静止跳过时长
          }
        } else {
          // 其他情况
          suggestedSkipDuration = 3; // 减少默认跳过时长
        }
      }
      
      // 如果建议跳过时长太短，取消跳过
      if (suggestedSkipDuration < 3) {
        isPossibleIntro = false;
        reason += "跳过时长过短，取消跳过; ";
      }
      
      return {
        isPossibleIntro,
        suggestedSkipDuration,
        confidence,
        reason,
        details: {
          hasFaces,
          hasText,
          hasAudio: hasSignificantAudio,
          sceneComplexity,
          isStaticScene,
          score
        }
      };
    } catch (error) {
      console.error('分析视频帧出错:', error);
      return {
        isPossibleIntro: false,
        suggestedSkipDuration: 0,
        confidence: 0,
        reason: "分析出错",
        details: {
          hasFaces: false,
          hasText: false,
          hasAudio: hasAudio,
          sceneComplexity: 0,
          isStaticScene: false,
          score: 0
        }
      };
    }
  }
  
  // 分析场景复杂度
  function analyzeSceneComplexity(canvas) {
    try {
      const context = canvas.getContext('2d');
      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
      const data = imageData.data;
      
      let edgeCount = 0;
      let colorVariation = 0;
      const width = canvas.width;
      
      // 边缘检测和颜色变化分析
      for (let y = 1; y < canvas.height - 1; y += 2) {
        for (let x = 1; x < width - 1; x += 2) {
          const pos = (y * width + x) * 4;
          const topPos = ((y - 1) * width + x) * 4;
          const leftPos = (y * width + (x - 1)) * 4;
          
          // 计算亮度差异
          const currentBrightness = (data[pos] + data[pos + 1] + data[pos + 2]) / 3;
          const topBrightness = (data[topPos] + data[topPos + 1] + data[topPos + 2]) / 3;
          const leftBrightness = (data[leftPos] + data[leftPos + 1] + data[leftPos + 2]) / 3;
          
          // 检测边缘
          if (Math.abs(currentBrightness - topBrightness) > 30 || 
              Math.abs(currentBrightness - leftBrightness) > 30) {
            edgeCount++;
          }
          
          // 计算颜色变化
          colorVariation += Math.abs(data[pos] - data[pos + 4]) +
                           Math.abs(data[pos + 1] - data[pos + 5]) +
                           Math.abs(data[pos + 2] - data[pos + 6]);
        }
      }
      
      // 归一化复杂度分数
      const totalPixels = (canvas.width * canvas.height) / 4;
      const edgeScore = edgeCount / totalPixels;
      const colorScore = colorVariation / (totalPixels * 3 * 255);
      
      return (edgeScore + colorScore) / 2;
    } catch (error) {
      console.error('分析场景复杂度失败:', error);
      return 0;
    }
  }
  
  // 检查静止画面
  function checkStaticScene(canvas) {
    try {
      if (!previousFrameData) {
        previousFrameData = canvas.getContext('2d').getImageData(0, 0, canvas.width, canvas.height).data;
        return false;
      }
      
      const currentFrameData = canvas.getContext('2d').getImageData(0, 0, canvas.width, canvas.height).data;
      const similarity = calculateImageSimilarity(previousFrameData, currentFrameData);
      
      previousFrameData = currentFrameData;
      return similarity > 0.95;
    } catch (error) {
      console.error('检查静止画面失败:', error);
      return false;
    }
  }
  
  // 分析音频特征
  function analyzeAudioFeatures(audioData) {
    if (!audioData) return {
      hasSignificantAudio: false,
      isBackgroundMusic: false,
      score: 0
    };
    
    try {
      // 计算平均音量
      const average = audioData.reduce((sum, value) => sum + value, 0) / audioData.length;
      
      // 计算音量变化
      let variation = 0;
      for (let i = 1; i < audioData.length; i++) {
        variation += Math.abs(audioData[i] - audioData[i - 1]);
      }
      variation /= audioData.length;
      
      // 判断是否为背景音乐
      const isBackgroundMusic = variation < 10 && average > 20;
      
      // 判断是否有显著音频
      const hasSignificantAudio = average > 15;
      
      return {
        hasSignificantAudio,
        isBackgroundMusic,
        score: average / 255
      };
    } catch (error) {
      console.error('分析音频特征失败:', error);
      return {
        hasSignificantAudio: false,
        isBackgroundMusic: false,
        score: 0
      };
    }
  }
  
  // 检测当前是否有音频
  function detectAudio() {
    if (!videoElement) return false;
    
    try {
      // 如果视频元素不可用或静音，认为没有音频
      if (videoElement.muted || videoElement.volume === 0) {
        return false;
      }
      
      if (!audioAnalyzer || !audioDataArray) {
        // 简单判断：如果视频没有静音且音量大于0
        return !videoElement.muted && videoElement.volume > 0;
      }
      
      try {
        // 使用Web Audio API分析音频
        audioAnalyzer.getByteFrequencyData(audioDataArray);
        
        // 计算平均音量
        const average = audioDataArray.reduce((sum, value) => sum + value, 0) / audioDataArray.length;
        
        // 如果平均音量大于阈值，认为有音频
        return average > 10;
      } catch (error) {
        console.error('音频分析出错:', error);
        return !videoElement.muted && videoElement.volume > 0;
      }
    } catch (error) {
      console.error('检测音频出错:', error);
      return false;
    }
  }
  
  // 简单的肤色检测（代替人脸检测）
  function detectSkin(canvas) {
    try {
      const context = canvas.getContext('2d');
      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
      const data = imageData.data;
      
      let skinPixels = 0;
      const totalPixels = data.length / 4;
      
      // 将画面分为9个区域，分别检测每个区域
      const regions = [
        { x: 0, y: 0, width: canvas.width/3, height: canvas.height/3 },           // 左上
        { x: canvas.width/3, y: 0, width: canvas.width/3, height: canvas.height/3 }, // 中上
        { x: canvas.width*2/3, y: 0, width: canvas.width/3, height: canvas.height/3 }, // 右上
        { x: 0, y: canvas.height/3, width: canvas.width/3, height: canvas.height/3 },  // 左中
        { x: canvas.width/3, y: canvas.height/3, width: canvas.width/3, height: canvas.height/3 }, // 中心
        { x: canvas.width*2/3, y: canvas.height/3, width: canvas.width/3, height: canvas.height/3 }, // 右中
        { x: 0, y: canvas.height*2/3, width: canvas.width/3, height: canvas.height/3 }, // 左下
        { x: canvas.width/3, y: canvas.height*2/3, width: canvas.width/3, height: canvas.height/3 }, // 中下
        { x: canvas.width*2/3, y: canvas.height*2/3, width: canvas.width/3, height: canvas.height/3 }  // 右下
      ];
      
      // 检查每个区域
      for (const region of regions) {
        let regionSkinPixels = 0;
        let regionTotalPixels = 0;
        
        // 在区域内采样检测
        for (let y = region.y; y < region.y + region.height; y += 2) {
          for (let x = region.x; x < region.x + region.width; x += 2) {
            const pos = (y * canvas.width + x) * 4;
            const r = data[pos];
            const g = data[pos + 1];
            const b = data[pos + 2];
            
            // 改进的肤色检测逻辑
            if (r > 60 && g > 40 && b > 20 && 
                r > g && r > b && 
                (r - g) > 15 && 
                Math.abs(r - g) < 60) {  // 增加肤色范围限制
              regionSkinPixels++;
            }
            regionTotalPixels++;
          }
        }
        
        // 如果某个区域的肤色像素占比超过阈值，认为该区域有人脸
        if (regionSkinPixels / regionTotalPixels > 0.05) {
          skinPixels += regionSkinPixels;
        }
      }
      
      // 降低整体肤色检测阈值，因为教育视频中可能只有部分人脸
      return (skinPixels / totalPixels) > 0.02;
    } catch (error) {
      console.error('肤色检测失败:', error);
      return false;
    }
  }
  
  // 简单的文字检测（基于边缘检测的简化版）
  function detectText(canvas) {
    try {
      const context = canvas.getContext('2d');
      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
      const data = imageData.data;
      const width = canvas.width;
      
      let edgeCount = 0;
      
      // 简化的边缘检测，每隔几行几列采样
      for (let y = 10; y < canvas.height - 10; y += 10) {
        for (let x = 10; x < width - 10; x += 10) {
          const pos = (y * width + x) * 4;
          const topPos = ((y - 5) * width + x) * 4;
          const leftPos = (y * width + (x - 5)) * 4;
          
          // 计算亮度差异
          const currentBrightness = (data[pos] + data[pos + 1] + data[pos + 2]) / 3;
          const topBrightness = (data[topPos] + data[topPos + 1] + data[topPos + 2]) / 3;
          const leftBrightness = (data[leftPos] + data[leftPos + 1] + data[leftPos + 2]) / 3;
          
          // 如果亮度差异大，可能是边缘
          if (Math.abs(currentBrightness - topBrightness) > 30 || 
              Math.abs(currentBrightness - leftBrightness) > 30) {
            edgeCount++;
          }
        }
      }
      
      // 如果边缘数量超过阈值，可能有文字
      return edgeCount > (canvas.width * canvas.height) / 2000;
    } catch (error) {
      console.error('文字检测失败:', error);
      return false;
    }
  }
  
  // 处理分析结果
  function handleAnalysisResult(result, currentTime) {
    if (!videoElement) return;
    
    if (result.isPossibleIntro) {
      // 根据工作模式决定如何处理
      if (currentMode === 'auto') {
        // 自动模式：直接跳过
        const skipToTime = currentTime + result.suggestedSkipDuration;
        
        // 确保不会跳过视频结尾
        if (skipToTime >= videoElement.duration) {
          console.log('视频片花跳过器: 跳过目标时间超过视频长度，取消跳过');
          return;
        }
        
        console.log(`视频片花跳过器: 自动跳过片花，从 ${formatTime(currentTime)} 到 ${formatTime(skipToTime)}`);
        console.log('跳过原因:', result.reason);
        
        // 记录跳过的片段
        const fromTime = currentTime;
        const toTime = skipToTime;
        const skippedSegment = {
          from: { 
            minutes: Math.floor(fromTime / 60), 
            seconds: Math.floor(fromTime % 60) 
          },
          to: { 
            minutes: Math.floor(toTime / 60), 
            seconds: Math.floor(toTime % 60) 
          },
          type: '自动识别',
          reason: result.reason
        };
        addSkippedSegment(skippedSegment);
        
        // 跳到建议的时间点
        try {
          videoElement.currentTime = skipToTime;
          console.log('视频片花跳过器: 已执行跳转');
        } catch (error) {
          console.error('视频片花跳过器: 跳转失败', error);
        }
      } else if (currentMode === 'prompt') {
        // 提示模式：显示确认对话框
        showSkipPrompt(currentTime, result.suggestedSkipDuration, result.reason);
      }
    }
  }
  
  // 显示跳过提示对话框 - 修改为居中显示
  function showSkipPrompt(currentTime, suggestedSkipDuration, reason) {
    if (!videoElement || promptDialogActive) return;
    
    promptDialogActive = true;
    
    // 计算跳过后的时间点
    const skipToTime = currentTime + suggestedSkipDuration;
    
    // 创建提示对话框
    const promptDialog = document.createElement('div');
    promptDialog.className = 'video-skipper-prompt';
    promptDialog.innerHTML = `
      <div class="video-skipper-prompt-content">
        <p>检测到可能的片花片段</p>
        <p>是否从 ${formatTime(currentTime)} 跳到 ${formatTime(skipToTime)}？</p>
        <p class="video-skipper-reason">${reason}</p>
        <div class="video-skipper-prompt-buttons">
          <button class="video-skipper-yes-btn">是</button>
          <button class="video-skipper-no-btn">否</button>
        </div>
      </div>
    `;
    
    // 添加样式
    const style = document.createElement('style');
    style.textContent = `
      .video-skipper-prompt {
        position: fixed;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
        z-index: 9999;
        background-color: rgba(0, 0, 0, 0.8);
        color: white;
        border-radius: 8px;
        padding: 15px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
        font-family: 'Microsoft YaHei', '微软雅黑', sans-serif;
        min-width: 250px;
      }
      .video-skipper-prompt-content {
        text-align: center;
      }
      .video-skipper-reason {
        font-size: 12px;
        color: #aaa;
        margin: 5px 0;
      }
      .video-skipper-prompt-buttons {
        display: flex;
        justify-content: space-around;
        margin-top: 10px;
      }
      .video-skipper-yes-btn, .video-skipper-no-btn {
        background-color: #2196F3;
        color: white;
        border: none;
        padding: 5px 15px;
        border-radius: 4px;
        cursor: pointer;
      }
      .video-skipper-no-btn {
        background-color: #757575;
      }
    `;
    
    document.head.appendChild(style);
    document.body.appendChild(promptDialog);
    
    // 计时器，10秒后自动关闭
    const timeoutId = setTimeout(() => {
      if (promptDialog.parentNode) {
        promptDialog.parentNode.removeChild(promptDialog);
      }
      promptDialogActive = false;
    }, 10000);
    
    // 添加按钮事件监听器
    const yesBtn = promptDialog.querySelector('.video-skipper-yes-btn');
    const noBtn = promptDialog.querySelector('.video-skipper-no-btn');
    
    yesBtn.addEventListener('click', () => {
      // 记录跳过的片段
      const fromTime = currentTime;
      const toTime = skipToTime;
      const skippedSegment = {
        from: { 
          minutes: Math.floor(fromTime / 60), 
          seconds: Math.floor(fromTime % 60) 
        },
        to: { 
          minutes: Math.floor(toTime / 60), 
          seconds: Math.floor(toTime % 60) 
        },
        type: '用户确认',
        reason: reason
      };
      addSkippedSegment(skippedSegment);
      
      // 跳到建议的时间点
      if (videoElement) {
        try {
          videoElement.currentTime = skipToTime;
          console.log('视频片花跳过器: 已执行跳转');
        } catch (error) {
          console.error('视频片花跳过器: 跳转失败', error);
        }
      }
      
      // 关闭对话框
      clearTimeout(timeoutId);
      if (promptDialog.parentNode) {
        promptDialog.parentNode.removeChild(promptDialog);
      }
      promptDialogActive = false;
    });
    
    noBtn.addEventListener('click', () => {
      // 关闭对话框
      clearTimeout(timeoutId);
      if (promptDialog.parentNode) {
        promptDialog.parentNode.removeChild(promptDialog);
      }
      promptDialogActive = false;
    });
  }
  
  // 添加到已跳过片段列表
  function addSkippedSegment(segment) {
    // 检查是否已有相同的片段
    const exists = skippedSegments.some(s => 
      s.from.minutes === segment.from.minutes && 
      s.from.seconds === segment.from.seconds && 
      s.to.minutes === segment.to.minutes && 
      s.to.seconds === segment.to.seconds && 
      s.type === segment.type
    );
    
    if (!exists) {
      skippedSegments.push(segment);
      try {
        // 保存到存储
        chrome.storage.local.set({ skippedSegments: skippedSegments });
      } catch (error) {
        console.error('保存跳过片段失败:', error);
      }
    }
  }
  
  // 格式化时间为 MM:SS 格式
  function formatTime(seconds) {
    const mins = Math.floor(seconds / 60);
    const secs = Math.floor(seconds % 60);
    return `${mins}:${secs < 10 ? '0' + secs : secs}`;
  }
  
  // 处理来自弹出窗口或后台脚本的消息
  function handleMessage(message, sender, sendResponse) {
    try {
      console.log('视频片花跳过器: 收到消息', message);
      
      if (!message.action) {
        sendResponse({ error: '无效的消息格式' });
        return false;
      }
      
      switch (message.action) {
        case 'checkVideo':
          // 检查页面是否有视频
          sendResponse({ hasVideo: videoElement !== null });
          break;
          
        case 'findVideo':
          // 主动寻找视频
          if (!videoElement) {
            // 可能视频刚刚加载，重新检测
            findVideoElement();
          }
          
          // 延迟响应，给视频查找一些时间
          setTimeout(() => {
            sendResponse({ hasVideo: videoElement !== null });
          }, 300);
          return true; // 异步响应
          
        case 'setMode':
          // 设置工作模式
          currentMode = message.mode;
          console.log(`视频片花跳过器: 模式已设置为 ${currentMode}`);
          
          // 当模式改变时，处理倍速控制界面
          if (currentMode === 'manual' && videoElement && !videoElement.paused) {
            createSpeedControlButton();
          } else if (currentMode !== 'manual') {
            removeSpeedControlButton();
            removeSpeedControlUI();
          }
          
          sendResponse({ success: true });
          break;
          
        case 'skipRange':
          // 手动设置跳过范围
          if (videoElement) {
            const fromSeconds = message.from;
            const toSeconds = message.to;
            const isRule = message.isRule || false;
            
            // 检查目标时间是否超过视频长度
            if (toSeconds > videoElement.duration) {
              console.log(`视频片花跳过器: 跳转目标时间 ${formatTime(toSeconds)} 超过视频长度 ${formatTime(videoElement.duration)}`);
              // 显示提示
              showTimeExceedPrompt(videoElement.duration);
              sendResponse({ success: false, error: '视频长度不足' });
              return true;
            }
            
            if (isRule) {
              // 添加为规则，而不是立即跳转
              addManualRule(fromSeconds, toSeconds);
              sendResponse({ success: true });
            } else {
              // 检查当前时间是否已在范围内
              const currentTime = videoElement.currentTime;
              if (currentTime >= fromSeconds && currentTime < toSeconds) {
                // 已在范围内，直接跳到结束时间
                videoElement.currentTime = toSeconds;
              } else if (currentTime < fromSeconds) {
                // 还没到起始时间，播放直到起始时间，然后跳过
                addManualRule(fromSeconds, toSeconds);
              } else {
                // 已经超过范围，不做处理
              }
              console.log(`视频片花跳过器: 已设置跳过区间 ${formatTime(fromSeconds)} 到 ${formatTime(toSeconds)}`);
              sendResponse({ success: true });
            }
          } else {
            sendResponse({ success: false, error: '未找到视频元素' });
          }
          break;
          
        case 'jumpTo':
          // 直接跳转到指定时间
          if (videoElement) {
            const jumpTime = message.time;
            
            // 检查跳转时间是否超过视频长度
            if (jumpTime > videoElement.duration) {
              console.log(`视频片花跳过器: 跳转目标时间 ${formatTime(jumpTime)} 超过视频长度 ${formatTime(videoElement.duration)}`);
              // 显示提示
              showTimeExceedPrompt(videoElement.duration);
              sendResponse({ success: false, error: '视频长度不足' });
              return true;
            }
            
            videoElement.currentTime = jumpTime;
            console.log(`视频片花跳过器: 已跳转到 ${formatTime(jumpTime)}`);
            sendResponse({ success: true });
          } else {
            sendResponse({ success: false, error: '未找到视频元素' });
          }
          break;
          
        case 'updateCustomRules':
          // 更新自定义规则
          customRules = message.rules;
          console.log('视频片花跳过器: 自定义规则已更新', customRules);
          
          // 更新活动规则
          updateActiveRules();
          
          sendResponse({ success: true });
          break;
          
        case 'getVideoStatus':
          // 获取视频状态
          if (videoElement) {
            const duration = videoElement.duration || 0;
            const currentTime = videoElement.currentTime || 0;
            sendResponse({
              hasVideo: true,
              status: {
                currentTime: currentTime,
                duration: duration,
                currentTimeFormatted: formatTime(currentTime),
                durationFormatted: formatTime(duration),
                paused: videoElement.paused,
                muted: videoElement.muted,
                volume: videoElement.volume
              }
            });
          } else {
            sendResponse({ hasVideo: false });
          }
          break;
          
        case 'setPlaybackSpeed':
          // 设置播放速度
          if (videoElement) {
            const speed = message.speed;
            if (setPlaybackSpeed(speed)) {
              console.log(`视频片花跳过器: 已设置播放速度为 ${speed}x`);
              sendResponse({ success: true });
            } else {
              sendResponse({ success: false, error: '设置播放速度失败' });
            }
          } else {
            sendResponse({ success: false, error: '未找到视频元素' });
          }
          break;
          
        case 'toggleSpeedControl':
          // 切换速度控制状态
          if (videoElement) {
            speedControlActive = !speedControlActive;
            if (speedControlActive) {
              // 激活速度控制，恢复之前的速度
              setPlaybackSpeed(currentSpeed);
            } else {
              // 停用速度控制，恢复正常速度
              setPlaybackSpeed(1);
            }
            console.log(`视频片花跳过器: 速度控制已${speedControlActive ? '激活' : '停用'}`);
            sendResponse({ success: true, active: speedControlActive });
          } else {
            sendResponse({ success: false, error: '未找到视频元素' });
          }
          break;
          
        default:
          sendResponse({ error: '未知操作类型' });
          break;
      }
      
      return true; // 返回true表示将异步发送响应
    } catch (error) {
      console.error('处理消息出错:', error);
      sendResponse({ error: error.message });
      return false;
    }
  }
  
  // 设置视频播放速度
  function setPlaybackSpeed(speed) {
    if (!videoElement) return false;
    
    try {
      // 检查速度是否在有效范围内
      if (speed < 0.25 || speed > 16) {
        console.error('视频片花跳过器: 无效的播放速度', speed);
        return false;
      }
      
      // 设置播放速度
      videoElement.playbackRate = speed;
      currentSpeed = speed;
      
      // 如果视频正在播放，确保速度设置生效
      if (!videoElement.paused) {
        videoElement.play();
      }
      
      return true;
    } catch (error) {
      console.error('设置播放速度出错:', error);
      return false;
    }
  }
  
  // 显示时间超出提示 - 修改为居中显示
  function showTimeExceedPrompt(duration) {
    // 防止多个提示同时显示
    const existingPrompt = document.querySelector('.video-skipper-time-exceed-prompt');
    if (existingPrompt) {
      existingPrompt.remove();
    }
    
    // 创建提示对话框
    const promptDiv = document.createElement('div');
    promptDiv.className = 'video-skipper-time-exceed-prompt';
    promptDiv.innerHTML = `
      <div class="video-skipper-prompt-content">
        <p>视频长度不足</p>
        <p>视频总长度: ${formatTime(duration)}</p>
        <div class="video-skipper-prompt-buttons">
          <button class="video-skipper-ok-btn">确定</button>
        </div>
      </div>
    `;
    
    // 添加样式
    const style = document.createElement('style');
    style.textContent = `
      .video-skipper-time-exceed-prompt {
        position: fixed;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
        z-index: 9999;
        background-color: rgba(0, 0, 0, 0.8);
        color: white;
        border-radius: 8px;
        padding: 15px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
        font-family: 'Microsoft YaHei', '微软雅黑', sans-serif;
        min-width: 250px;
      }
      .video-skipper-prompt-content {
        text-align: center;
      }
      .video-skipper-prompt-buttons {
        display: flex;
        justify-content: center;
        margin-top: 10px;
      }
      .video-skipper-ok-btn {
        background-color: #2196F3;
        color: white;
        border: none;
        padding: 5px 15px;
        border-radius: 4px;
        cursor: pointer;
      }
    `;
    
    document.head.appendChild(style);
    document.body.appendChild(promptDiv);
    
    // 计时器，5秒后自动关闭
    const timeoutId = setTimeout(() => {
      if (promptDiv.parentNode) {
        promptDiv.parentNode.removeChild(promptDiv);
      }
    }, 5000);
    
    // 添加按钮事件监听器
    const okBtn = promptDiv.querySelector('.video-skipper-ok-btn');
    okBtn.addEventListener('click', () => {
      clearTimeout(timeoutId);
      if (promptDiv.parentNode) {
        promptDiv.parentNode.removeChild(promptDiv);
      }
    });
  }
  
  // 创建倍速控制启动按钮
  function createSpeedControlButton() {
    // 如果不是手动模式，则退出
    if (currentMode !== 'manual') return;
    
    // 检查是否已存在按钮
    if (document.querySelector('.video-skipper-speed-button')) return;
    
    // 创建按钮
    const speedButton = document.createElement('div');
    speedButton.className = 'video-skipper-speed-button';
    speedButton.innerHTML = '<span>倍速</span>';
    
    // 添加样式
    const style = document.createElement('style');
    style.textContent = `
      .video-skipper-speed-button {
        position: fixed;
        bottom: 20px;
        right: 20px;
        background-color: rgba(33, 150, 243, 0.8);
        color: white;
        border-radius: 50%;
        width: 50px;
        height: 50px;
        display: flex;
        align-items: center;
        justify-content: center;
        cursor: pointer;
        z-index: 9998;
        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3);
        font-family: 'Microsoft YaHei', '微软雅黑', sans-serif;
        user-select: none;
      }
      .video-skipper-speed-button:hover {
        background-color: rgba(33, 150, 243, 1);
        transform: scale(1.05);
      }
    `;
    
    document.head.appendChild(style);
    document.body.appendChild(speedButton);
    
    // 添加点击事件
    speedButton.addEventListener('click', () => {
      // 如果控制面板已显示，则隐藏；否则显示
      if (speedControlDiv) {
        removeSpeedControlUI();
      } else {
        createSpeedControlUI();
      }
    });
    
    console.log('视频片花跳过器: 倍速控制启动按钮已创建');
  }
  
  // 移除倍速控制启动按钮
  function removeSpeedControlButton() {
    const speedButton = document.querySelector('.video-skipper-speed-button');
    if (speedButton) {
      speedButton.parentNode.removeChild(speedButton);
      console.log('视频片花跳过器: 倍速控制启动按钮已移除');
    }
  }
  
  // 创建倍速控制界面
  function createSpeedControlUI() {
    // 如果不是手动模式或已存在界面，则退出
    if (currentMode !== 'manual' || speedControlDiv) return;
    
    // 先移除可能存在的旧界面
    removeSpeedControlUI();
    
    // 创建界面容器
    speedControlDiv = document.createElement('div');
    speedControlDiv.className = 'video-skipper-speed-control';
    
    // 设置HTML内容
    speedControlDiv.innerHTML = `
      <div class="video-skipper-speed-content">
        <div class="video-skipper-speed-title">视频倍速播放</div>
        <div class="video-skipper-speed-buttons">
          <button class="video-skipper-speed-btn" data-speed="1">1x</button>
          <button class="video-skipper-speed-btn" data-speed="2">2x</button>
          <button class="video-skipper-speed-btn" data-speed="4">4x</button>
          <button class="video-skipper-speed-btn" data-speed="8">8x</button>
          <button class="video-skipper-speed-btn" data-speed="16">16x</button>
        </div>
        <div class="video-skipper-speed-controls">
          <button class="video-skipper-speed-close">关闭</button>
        </div>
      </div>
    `;
    
    // 添加样式
    const style = document.createElement('style');
    style.textContent = `
      .video-skipper-speed-control {
        position: fixed;
        bottom: 20px;
        left: 50%;
        transform: translateX(-50%);
        z-index: 9999;
        background-color: rgba(0, 0, 0, 0.8);
        color: white;
        border-radius: 8px;
        padding: 10px 15px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
        font-family: 'Microsoft YaHei', '微软雅黑', sans-serif;
        user-select: none;
        min-width: 250px;
      }
      .video-skipper-speed-content {
        text-align: center;
      }
      .video-skipper-speed-title {
        font-size: 14px;
        margin-bottom: 8px;
        font-weight: bold;
      }
      .video-skipper-speed-buttons {
        display: flex;
        justify-content: center;
        gap: 8px;
        margin-bottom: 8px;
      }
      .video-skipper-speed-btn {
        background-color: #424242;
        color: white;
        border: none;
        padding: 5px 10px;
        border-radius: 4px;
        cursor: pointer;
        min-width: 40px;
      }
      .video-skipper-speed-btn.active {
        background-color: #2196F3;
      }
      .video-skipper-speed-controls {
        display: flex;
        justify-content: center;
      }
      .video-skipper-speed-close {
        background-color: #757575;
        color: white;
        border: none;
        padding: 5px 15px;
        border-radius: 4px;
        cursor: pointer;
      }
    `;
    
    document.head.appendChild(style);
    document.body.appendChild(speedControlDiv);
    
    // 保存原始速度
    originalSpeed = videoElement.playbackRate;
    
    // 添加事件监听器
    // 速度选择按钮
    const speedButtons = speedControlDiv.querySelectorAll('.video-skipper-speed-btn');
    speedButtons.forEach(button => {
      button.addEventListener('click', () => {
        // 移除所有按钮的active类
        speedButtons.forEach(btn => btn.classList.remove('active'));
        // 给当前按钮添加active类
        button.classList.add('active');
        // 直接应用选中的速度
        currentSpeed = parseFloat(button.getAttribute('data-speed'));
        setPlaybackSpeed(currentSpeed);
        speedControlActive = true;
        console.log(`视频片花跳过器: 已设置播放速度为 ${currentSpeed}x`);
      });
    });
    
    // 关闭按钮
    const closeButton = speedControlDiv.querySelector('.video-skipper-speed-close');
    closeButton.addEventListener('click', () => {
      // 移除界面但不改变当前播放状态
      removeSpeedControlUI();
    });
    
    console.log('视频片花跳过器: 倍速控制界面已创建');
  }
  
  // 移除倍速控制界面
  function removeSpeedControlUI() {
    if (speedControlDiv && speedControlDiv.parentNode) {
      speedControlDiv.parentNode.removeChild(speedControlDiv);
      speedControlDiv = null;
      console.log('视频片花跳过器: 倍速控制界面已移除');
    }
  }
  
  // 初始化
  init();
})(); 